﻿#region Using directives

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Configuration.Provider;
using System.Web.Configuration;
using System.Web;
using Indeco.G24.Entities;
using Indeco.G24.Data;
using Indeco.G24.Data.Bases;

#endregion

namespace Indeco.G24.Data
{
	/// <summary>
	/// This class represents the Data source repository and gives access to all the underlying providers.
	/// </summary>
	[CLSCompliant(true)]
	public sealed class DataRepository 
	{
		private static volatile NetTiersProvider _provider = null;
        private static volatile NetTiersProviderCollection _providers = null;
		private static volatile NetTiersServiceSection _section = null;
		private static volatile Configuration _config = null;
        
        private static object SyncRoot = new object();
				
		private DataRepository()
		{
		}
		
		#region Public LoadProvider
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        public static void LoadProvider(NetTiersProvider provider)
        {
			LoadProvider(provider, false);
        }
		
		/// <summary>
        /// Enables the DataRepository to programatically create and 
        /// pass in a <c>NetTiersProvider</c> during runtime.
        /// </summary>
        /// <param name="provider">An instatiated NetTiersProvider.</param>
        /// <param name="setAsDefault">ability to set any valid provider as the default provider for the DataRepository.</param>
		public static void LoadProvider(NetTiersProvider provider, bool setAsDefault)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");

            if (_providers == null)
			{
				lock(SyncRoot)
				{
            		if (_providers == null)
						_providers = new NetTiersProviderCollection();
				}
			}
			
            if (_providers[provider.Name] == null)
            {
                lock (_providers.SyncRoot)
                {
                    _providers.Add(provider);
                }
            }

            if (_provider == null || setAsDefault)
            {
                lock (SyncRoot)
                {
                    if(_provider == null || setAsDefault)
                         _provider = provider;
                }
            }
        }
		#endregion 
		
		///<summary>
		/// Configuration based provider loading, will load the providers on first call.
		///</summary>
		private static void LoadProviders()
        {
            // Avoid claiming lock if providers are already loaded
            if (_provider == null)
            {
                lock (SyncRoot)
                {
                    // Do this again to make sure _provider is still null
                    if (_provider == null)
                    {
                        // Load registered providers and point _provider to the default provider
                        _providers = new NetTiersProviderCollection();

                        ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
						_provider = _providers[NetTiersSection.DefaultProvider];

                        if (_provider == null)
                        {
                            throw new ProviderException("Unable to load default NetTiersProvider");
                        }
                    }
                }
            }
        }

		/// <summary>
        /// Gets the provider.
        /// </summary>
        /// <value>The provider.</value>
        public static NetTiersProvider Provider
        {
            get { LoadProviders(); return _provider; }
        }

		/// <summary>
        /// Gets the provider collection.
        /// </summary>
        /// <value>The providers.</value>
        public static NetTiersProviderCollection Providers
        {
            get { LoadProviders(); return _providers; }
        }
		
		/// <summary>
		/// Creates a new <c cref="TransactionManager"/> instance from the current datasource.
		/// </summary>
		/// <returns></returns>
		public TransactionManager CreateTransaction()
		{
			return _provider.CreateTransaction();
		}

		#region Configuration

		/// <summary>
		/// Gets a reference to the configured NetTiersServiceSection object.
		/// </summary>
		public static NetTiersServiceSection NetTiersSection
		{
			get
			{
				// Try to get a reference to the default <netTiersService> section
				_section = WebConfigurationManager.GetSection("netTiersService") as NetTiersServiceSection;

				if ( _section == null )
				{
					// otherwise look for section based on the assembly name
					_section = WebConfigurationManager.GetSection("Indeco.G24.Data") as NetTiersServiceSection;
				}

				#region Design-Time Support

				if ( _section == null )
				{
					// lastly, try to find the specific NetTiersServiceSection for this assembly
					foreach ( ConfigurationSection temp in Configuration.Sections )
					{
						if ( temp is NetTiersServiceSection )
						{
							_section = temp as NetTiersServiceSection;
							break;
						}
					}
				}

				#endregion Design-Time Support
				
				if ( _section == null )
				{
					throw new ProviderException("Unable to load NetTiersServiceSection");
				}

				return _section;
			}
		}

		#region Design-Time Support

		/// <summary>
		/// Gets a reference to the application configuration object.
		/// </summary>
		public static Configuration Configuration
		{
			get
			{
				if ( _config == null )
				{
					// load specific config file
					if ( HttpContext.Current != null )
					{
						_config = WebConfigurationManager.OpenWebConfiguration("~");
					}
					else
					{
						String configFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile.Replace(".config", "").Replace(".temp", "");

						// check for design mode
						if ( configFile.ToLower().Contains("devenv.exe") )
						{
							_config = GetDesignTimeConfig();
						}
						else
						{
							_config = ConfigurationManager.OpenExeConfiguration(configFile);
						}
					}
				}

				return _config;
			}
		}

		private static Configuration GetDesignTimeConfig()
		{
			ExeConfigurationFileMap configMap = null;
			Configuration config = null;
			String path = null;

			// Get an instance of the currently running Visual Studio IDE.
			EnvDTE80.DTE2 dte = (EnvDTE80.DTE2) System.Runtime.InteropServices.Marshal.GetActiveObject("VisualStudio.DTE.8.0");
			if ( dte != null )
			{
				dte.SuppressUI = true;

				EnvDTE.ProjectItem item = dte.Solution.FindProjectItem("web.config");
				if ( item != null )
				{
					if (!item.ContainingProject.FullName.ToLower().StartsWith("http:"))
               {
                  System.IO.FileInfo info = new System.IO.FileInfo(item.ContainingProject.FullName);
                  path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = path;
               }
               else
               {
                  configMap = new ExeConfigurationFileMap();
                  configMap.ExeConfigFilename = item.get_FileNames(0);
               }}

				/*
				Array projects = (Array) dte2.ActiveSolutionProjects;
				EnvDTE.Project project = (EnvDTE.Project) projects.GetValue(0);
				System.IO.FileInfo info;

				foreach ( EnvDTE.ProjectItem item in project.ProjectItems )
				{
					if ( String.Compare(item.Name, "web.config", true) == 0 )
					{
						info = new System.IO.FileInfo(project.FullName);
						path = String.Format("{0}\\{1}", info.Directory.FullName, item.Name);
						configMap = new ExeConfigurationFileMap();
						configMap.ExeConfigFilename = path;
						break;
					}
				}
				*/
			}

			config = ConfigurationManager.OpenMappedExeConfiguration(configMap, ConfigurationUserLevel.None);
			return config;
		}

		#endregion Design-Time Support

		#endregion Configuration

		#region Connections

		/// <summary>
		/// Gets a reference to the ConnectionStringSettings collection.
		/// </summary>
		public static ConnectionStringSettingsCollection ConnectionStrings
		{
			get
			{
				// use default ConnectionStrings if _section has already been discovered
				if ( _config == null && _section != null )
				{
					return WebConfigurationManager.ConnectionStrings;
				}
				
				return Configuration.ConnectionStrings.ConnectionStrings;
			}
		}

		// dictionary of connection providers
		private static Dictionary<String, ConnectionProvider> _connections;

		/// <summary>
		/// Gets the dictionary of connection providers.
		/// </summary>
		public static Dictionary<String, ConnectionProvider> Connections
		{
			get
			{
				if ( _connections == null )
				{
					lock (SyncRoot)
                	{
						if (_connections == null)
						{
							_connections = new Dictionary<String, ConnectionProvider>();
		
							// add a connection provider for each configured connection string
							foreach ( ConnectionStringSettings conn in ConnectionStrings )
							{
								_connections.Add(conn.Name, new ConnectionProvider(conn.Name));
							}
						}
					}
				}

				return _connections;
			}
		}

		/// <summary>
		/// Adds the specified connection string to the map of connection strings.
		/// </summary>
		/// <param name="connectionStringName">The connection string name.</param>
		/// <param name="connectionString">The provider specific connection information.</param>
		public static void AddConnection(String connectionStringName, String connectionString)
		{
			lock (SyncRoot)
            {
				Connections.Remove(connectionStringName);
				ConnectionProvider connection = new ConnectionProvider(connectionStringName, connectionString);
				Connections.Add(connectionStringName, connection);
			}
		}

		/// <summary>
		/// Provides ability to switch connection string at runtime.
		/// </summary>
		public sealed class ConnectionProvider
		{
			private NetTiersProvider _provider;
			private NetTiersProviderCollection _providers;
			private String _connectionStringName;
			private String _connectionString;

			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			public ConnectionProvider(String connectionStringName)
			{
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Initializes a new instance of the ConnectionProvider class.
			/// </summary>
			/// <param name="connectionStringName">The connection string name.</param>
			/// <param name="connectionString">The provider specific connection information.</param>
			public ConnectionProvider(String connectionStringName, String connectionString)
			{
				_connectionString = connectionString;
				_connectionStringName = connectionStringName;
			}

			/// <summary>
			/// Gets the provider.
			/// </summary>
			public NetTiersProvider Provider
			{
				get { LoadProviders(); return _provider; }
			}

			/// <summary>
			/// Gets the provider collection.
			/// </summary>
			public NetTiersProviderCollection Providers
			{
				get { LoadProviders(); return _providers; }
			}

			/// <summary>
			/// Instantiates the configured providers based on the supplied connection string.
			/// </summary>
			private void LoadProviders()
			{
				DataRepository.LoadProviders();

				// Avoid claiming lock if providers are already loaded
				if ( _providers == null )
				{
					lock ( SyncRoot )
					{
						// Do this again to make sure _provider is still null
						if ( _providers == null )
						{
							// apply connection information to each provider
							for ( int i = 0; i < NetTiersSection.Providers.Count; i++ )
							{
								NetTiersSection.Providers[i].Parameters["connectionStringName"] = _connectionStringName;
								// remove previous connection string, if any
								NetTiersSection.Providers[i].Parameters.Remove("connectionString");

								if ( !String.IsNullOrEmpty(_connectionString) )
								{
									NetTiersSection.Providers[i].Parameters["connectionString"] = _connectionString;
								}
							}

							// Load registered providers and point _provider to the default provider
							_providers = new NetTiersProviderCollection();

							ProvidersHelper.InstantiateProviders(NetTiersSection.Providers, _providers, typeof(NetTiersProvider));
							_provider = _providers[NetTiersSection.DefaultProvider];
						}
					}
				}
			}
		}

		#endregion Connections

		#region Static properties
		
		#region NhaCungCapProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NhaCungCap"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NhaCungCapProviderBase NhaCungCapProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NhaCungCapProvider;
			}
		}
		
		#endregion
		
		#region SanPhamBinhLuanProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SanPhamBinhLuan"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SanPhamBinhLuanProviderBase SanPhamBinhLuanProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SanPhamBinhLuanProvider;
			}
		}
		
		#endregion
		
		#region TinTucProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TinTuc"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TinTucProviderBase TinTucProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TinTucProvider;
			}
		}
		
		#endregion
		
		#region SanPhamDanhMucProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SanPhamDanhMuc"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SanPhamDanhMucProviderBase SanPhamDanhMucProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SanPhamDanhMucProvider;
			}
		}
		
		#endregion
		
		#region SanPhamProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="SanPham"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static SanPhamProviderBase SanPhamProvider
		{
			get 
			{
				LoadProviders();
				return _provider.SanPhamProvider;
			}
		}
		
		#endregion
		
		#region NhaCungCapSanPhamDanhMucProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NhaCungCapSanPhamDanhMuc"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NhaCungCapSanPhamDanhMucProviderBase NhaCungCapSanPhamDanhMucProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NhaCungCapSanPhamDanhMucProvider;
			}
		}
		
		#endregion
		
		#region NhaSanXuatProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NhaSanXuat"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NhaSanXuatProviderBase NhaSanXuatProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NhaSanXuatProvider;
			}
		}
		
		#endregion
		
		#region QuanLyFileProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="QuanLyFile"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static QuanLyFileProviderBase QuanLyFileProvider
		{
			get 
			{
				LoadProviders();
				return _provider.QuanLyFileProvider;
			}
		}
		
		#endregion
		
		#region TinTucBinhLuanProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TinTucBinhLuan"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TinTucBinhLuanProviderBase TinTucBinhLuanProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TinTucBinhLuanProvider;
			}
		}
		
		#endregion
		
		#region DiaBanProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DiaBan"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DiaBanProviderBase DiaBanProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DiaBanProvider;
			}
		}
		
		#endregion
		
		#region TinTucTheoChuDeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TinTucTheoChuDe"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TinTucTheoChuDeProviderBase TinTucTheoChuDeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TinTucTheoChuDeProvider;
			}
		}
		
		#endregion
		
		#region VaiTroProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="VaiTro"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static VaiTroProviderBase VaiTroProvider
		{
			get 
			{
				LoadProviders();
				return _provider.VaiTroProvider;
			}
		}
		
		#endregion
		
		#region TinTucTieuDiemProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TinTucTieuDiem"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TinTucTieuDiemProviderBase TinTucTieuDiemProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TinTucTieuDiemProvider;
			}
		}
		
		#endregion
		
		#region TinTucDanhMucProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TinTucDanhMuc"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TinTucDanhMucProviderBase TinTucDanhMucProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TinTucDanhMucProvider;
			}
		}
		
		#endregion
		
		#region NgoaiTeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NgoaiTe"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NgoaiTeProviderBase NgoaiTeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NgoaiTeProvider;
			}
		}
		
		#endregion
		
		#region TinTucChuDeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TinTucChuDe"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TinTucChuDeProviderBase TinTucChuDeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TinTucChuDeProvider;
			}
		}
		
		#endregion
		
		#region TinTucSuKienProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="TinTucSuKien"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static TinTucSuKienProviderBase TinTucSuKienProvider
		{
			get 
			{
				LoadProviders();
				return _provider.TinTucSuKienProvider;
			}
		}
		
		#endregion
		
		#region NhaCungCapNganhNgheKinhDoanhProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NhaCungCapNganhNgheKinhDoanh"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NhaCungCapNganhNgheKinhDoanhProviderBase NhaCungCapNganhNgheKinhDoanhProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NhaCungCapNganhNgheKinhDoanhProvider;
			}
		}
		
		#endregion
		
		#region NganhNgheKinhDoanhProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NganhNgheKinhDoanh"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NganhNgheKinhDoanhProviderBase NganhNgheKinhDoanhProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NganhNgheKinhDoanhProvider;
			}
		}
		
		#endregion
		
		#region NgheNghiepProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NgheNghiep"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NgheNghiepProviderBase NgheNghiepProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NgheNghiepProvider;
			}
		}
		
		#endregion
		
		#region NguoiDungProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NguoiDung"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NguoiDungProviderBase NguoiDungProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NguoiDungProvider;
			}
		}
		
		#endregion
		
		#region LienHeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="LienHe"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static LienHeProviderBase LienHeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.LienHeProvider;
			}
		}
		
		#endregion
		
		#region BangGiaSanPhamProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="BangGiaSanPham"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static BangGiaSanPhamProviderBase BangGiaSanPhamProvider
		{
			get 
			{
				LoadProviders();
				return _provider.BangGiaSanPhamProvider;
			}
		}
		
		#endregion
		
		#region CauHinhHeThongProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="CauHinhHeThong"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static CauHinhHeThongProviderBase CauHinhHeThongProvider
		{
			get 
			{
				LoadProviders();
				return _provider.CauHinhHeThongProvider;
			}
		}
		
		#endregion
		
		#region DonViTinhProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="DonViTinh"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static DonViTinhProviderBase DonViTinhProvider
		{
			get 
			{
				LoadProviders();
				return _provider.DonViTinhProvider;
			}
		}
		
		#endregion
		
		#region NhaCungCapCauHinhProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NhaCungCapCauHinh"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NhaCungCapCauHinhProviderBase NhaCungCapCauHinhProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NhaCungCapCauHinhProvider;
			}
		}
		
		#endregion
		
		#region NhaCungCapDiaBanProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NhaCungCapDiaBan"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NhaCungCapDiaBanProviderBase NhaCungCapDiaBanProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NhaCungCapDiaBanProvider;
			}
		}
		
		#endregion
		
		#region NhaCungCapLienHeProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NhaCungCapLienHe"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NhaCungCapLienHeProviderBase NhaCungCapLienHeProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NhaCungCapLienHeProvider;
			}
		}
		
		#endregion
		
		#region NguoiDungVaiTroProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NguoiDungVaiTro"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NguoiDungVaiTroProviderBase NguoiDungVaiTroProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NguoiDungVaiTroProvider;
			}
		}
		
		#endregion
		
		#region NguoiDungDiaBanProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NguoiDungDiaBan"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NguoiDungDiaBanProviderBase NguoiDungDiaBanProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NguoiDungDiaBanProvider;
			}
		}
		
		#endregion
		
		#region NguoiDungNgheNghiepProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NguoiDungNgheNghiep"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NguoiDungNgheNghiepProviderBase NguoiDungNgheNghiepProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NguoiDungNgheNghiepProvider;
			}
		}
		
		#endregion
		
		#region NguoiDungNhaCungCapProvider

		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="NguoiDungNhaCungCap"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static NguoiDungNhaCungCapProviderBase NguoiDungNhaCungCapProvider
		{
			get 
			{
				LoadProviders();
				return _provider.NguoiDungNhaCungCapProvider;
			}
		}
		
		#endregion
		
		
		#region ViewBangGiaSanPhamProvider
		
		///<summary>
		/// Gets the current instance of the Data Access Logic Component for the <see cref="ViewBangGiaSanPham"/> business entity.
		/// It exposes CRUD methods as well as selecting on index, foreign keys and custom stored procedures.
		///</summary>
		public static ViewBangGiaSanPhamProviderBase ViewBangGiaSanPhamProvider
		{
			get 
			{
				LoadProviders();
				return _provider.ViewBangGiaSanPhamProvider;
			}
		}
		
		#endregion
		
		#endregion
	}
	
	#region Query/Filters
		
	#region NhaCungCapFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NhaCungCap"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaCungCapFilters : NhaCungCapFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaCungCapFilters class.
		/// </summary>
		public NhaCungCapFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaCungCapFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaCungCapFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaCungCapFilters
	
	#region NhaCungCapQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NhaCungCapParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NhaCungCap"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaCungCapQuery : NhaCungCapParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaCungCapQuery class.
		/// </summary>
		public NhaCungCapQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaCungCapQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaCungCapQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaCungCapQuery
		
	#region SanPhamBinhLuanFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SanPhamBinhLuan"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SanPhamBinhLuanFilters : SanPhamBinhLuanFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SanPhamBinhLuanFilters class.
		/// </summary>
		public SanPhamBinhLuanFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SanPhamBinhLuanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SanPhamBinhLuanFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SanPhamBinhLuanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SanPhamBinhLuanFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SanPhamBinhLuanFilters
	
	#region SanPhamBinhLuanQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SanPhamBinhLuanParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SanPhamBinhLuan"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SanPhamBinhLuanQuery : SanPhamBinhLuanParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SanPhamBinhLuanQuery class.
		/// </summary>
		public SanPhamBinhLuanQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SanPhamBinhLuanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SanPhamBinhLuanQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SanPhamBinhLuanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SanPhamBinhLuanQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SanPhamBinhLuanQuery
		
	#region TinTucFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TinTuc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucFilters : TinTucFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucFilters class.
		/// </summary>
		public TinTucFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucFilters
	
	#region TinTucQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TinTucParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TinTuc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucQuery : TinTucParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucQuery class.
		/// </summary>
		public TinTucQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucQuery
		
	#region SanPhamDanhMucFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SanPhamDanhMuc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SanPhamDanhMucFilters : SanPhamDanhMucFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SanPhamDanhMucFilters class.
		/// </summary>
		public SanPhamDanhMucFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SanPhamDanhMucFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SanPhamDanhMucFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SanPhamDanhMucFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SanPhamDanhMucFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SanPhamDanhMucFilters
	
	#region SanPhamDanhMucQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SanPhamDanhMucParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SanPhamDanhMuc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SanPhamDanhMucQuery : SanPhamDanhMucParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SanPhamDanhMucQuery class.
		/// </summary>
		public SanPhamDanhMucQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SanPhamDanhMucQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SanPhamDanhMucQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SanPhamDanhMucQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SanPhamDanhMucQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SanPhamDanhMucQuery
		
	#region SanPhamFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="SanPham"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SanPhamFilters : SanPhamFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SanPhamFilters class.
		/// </summary>
		public SanPhamFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the SanPhamFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SanPhamFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SanPhamFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SanPhamFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SanPhamFilters
	
	#region SanPhamQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SanPhamParameterBuilder"/> class
	/// that is used exclusively with a <see cref="SanPham"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class SanPhamQuery : SanPhamParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the SanPhamQuery class.
		/// </summary>
		public SanPhamQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the SanPhamQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public SanPhamQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the SanPhamQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public SanPhamQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion SanPhamQuery
		
	#region NhaCungCapSanPhamDanhMucFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NhaCungCapSanPhamDanhMuc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaCungCapSanPhamDanhMucFilters : NhaCungCapSanPhamDanhMucFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaCungCapSanPhamDanhMucFilters class.
		/// </summary>
		public NhaCungCapSanPhamDanhMucFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapSanPhamDanhMucFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaCungCapSanPhamDanhMucFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapSanPhamDanhMucFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaCungCapSanPhamDanhMucFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaCungCapSanPhamDanhMucFilters
	
	#region NhaCungCapSanPhamDanhMucQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NhaCungCapSanPhamDanhMucParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NhaCungCapSanPhamDanhMuc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaCungCapSanPhamDanhMucQuery : NhaCungCapSanPhamDanhMucParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaCungCapSanPhamDanhMucQuery class.
		/// </summary>
		public NhaCungCapSanPhamDanhMucQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapSanPhamDanhMucQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaCungCapSanPhamDanhMucQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapSanPhamDanhMucQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaCungCapSanPhamDanhMucQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaCungCapSanPhamDanhMucQuery
		
	#region NhaSanXuatFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NhaSanXuat"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaSanXuatFilters : NhaSanXuatFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaSanXuatFilters class.
		/// </summary>
		public NhaSanXuatFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaSanXuatFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaSanXuatFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaSanXuatFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaSanXuatFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaSanXuatFilters
	
	#region NhaSanXuatQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NhaSanXuatParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NhaSanXuat"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaSanXuatQuery : NhaSanXuatParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaSanXuatQuery class.
		/// </summary>
		public NhaSanXuatQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaSanXuatQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaSanXuatQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaSanXuatQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaSanXuatQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaSanXuatQuery
		
	#region QuanLyFileFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="QuanLyFile"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class QuanLyFileFilters : QuanLyFileFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the QuanLyFileFilters class.
		/// </summary>
		public QuanLyFileFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the QuanLyFileFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public QuanLyFileFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the QuanLyFileFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public QuanLyFileFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion QuanLyFileFilters
	
	#region QuanLyFileQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="QuanLyFileParameterBuilder"/> class
	/// that is used exclusively with a <see cref="QuanLyFile"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class QuanLyFileQuery : QuanLyFileParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the QuanLyFileQuery class.
		/// </summary>
		public QuanLyFileQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the QuanLyFileQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public QuanLyFileQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the QuanLyFileQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public QuanLyFileQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion QuanLyFileQuery
		
	#region TinTucBinhLuanFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TinTucBinhLuan"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucBinhLuanFilters : TinTucBinhLuanFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucBinhLuanFilters class.
		/// </summary>
		public TinTucBinhLuanFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucBinhLuanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucBinhLuanFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucBinhLuanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucBinhLuanFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucBinhLuanFilters
	
	#region TinTucBinhLuanQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TinTucBinhLuanParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TinTucBinhLuan"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucBinhLuanQuery : TinTucBinhLuanParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucBinhLuanQuery class.
		/// </summary>
		public TinTucBinhLuanQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucBinhLuanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucBinhLuanQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucBinhLuanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucBinhLuanQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucBinhLuanQuery
		
	#region DiaBanFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DiaBan"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DiaBanFilters : DiaBanFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DiaBanFilters class.
		/// </summary>
		public DiaBanFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DiaBanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DiaBanFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DiaBanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DiaBanFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DiaBanFilters
	
	#region DiaBanQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DiaBanParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DiaBan"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DiaBanQuery : DiaBanParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DiaBanQuery class.
		/// </summary>
		public DiaBanQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DiaBanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DiaBanQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DiaBanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DiaBanQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DiaBanQuery
		
	#region TinTucTheoChuDeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TinTucTheoChuDe"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucTheoChuDeFilters : TinTucTheoChuDeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucTheoChuDeFilters class.
		/// </summary>
		public TinTucTheoChuDeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucTheoChuDeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucTheoChuDeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucTheoChuDeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucTheoChuDeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucTheoChuDeFilters
	
	#region TinTucTheoChuDeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TinTucTheoChuDeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TinTucTheoChuDe"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucTheoChuDeQuery : TinTucTheoChuDeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucTheoChuDeQuery class.
		/// </summary>
		public TinTucTheoChuDeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucTheoChuDeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucTheoChuDeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucTheoChuDeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucTheoChuDeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucTheoChuDeQuery
		
	#region VaiTroFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="VaiTro"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VaiTroFilters : VaiTroFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VaiTroFilters class.
		/// </summary>
		public VaiTroFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the VaiTroFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VaiTroFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VaiTroFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VaiTroFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VaiTroFilters
	
	#region VaiTroQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="VaiTroParameterBuilder"/> class
	/// that is used exclusively with a <see cref="VaiTro"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class VaiTroQuery : VaiTroParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the VaiTroQuery class.
		/// </summary>
		public VaiTroQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the VaiTroQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public VaiTroQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the VaiTroQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public VaiTroQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion VaiTroQuery
		
	#region TinTucTieuDiemFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TinTucTieuDiem"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucTieuDiemFilters : TinTucTieuDiemFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucTieuDiemFilters class.
		/// </summary>
		public TinTucTieuDiemFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucTieuDiemFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucTieuDiemFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucTieuDiemFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucTieuDiemFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucTieuDiemFilters
	
	#region TinTucTieuDiemQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TinTucTieuDiemParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TinTucTieuDiem"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucTieuDiemQuery : TinTucTieuDiemParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucTieuDiemQuery class.
		/// </summary>
		public TinTucTieuDiemQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucTieuDiemQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucTieuDiemQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucTieuDiemQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucTieuDiemQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucTieuDiemQuery
		
	#region TinTucDanhMucFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TinTucDanhMuc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucDanhMucFilters : TinTucDanhMucFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucDanhMucFilters class.
		/// </summary>
		public TinTucDanhMucFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucDanhMucFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucDanhMucFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucDanhMucFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucDanhMucFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucDanhMucFilters
	
	#region TinTucDanhMucQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TinTucDanhMucParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TinTucDanhMuc"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucDanhMucQuery : TinTucDanhMucParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucDanhMucQuery class.
		/// </summary>
		public TinTucDanhMucQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucDanhMucQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucDanhMucQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucDanhMucQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucDanhMucQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucDanhMucQuery
		
	#region NgoaiTeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NgoaiTe"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NgoaiTeFilters : NgoaiTeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NgoaiTeFilters class.
		/// </summary>
		public NgoaiTeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NgoaiTeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NgoaiTeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NgoaiTeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NgoaiTeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NgoaiTeFilters
	
	#region NgoaiTeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NgoaiTeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NgoaiTe"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NgoaiTeQuery : NgoaiTeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NgoaiTeQuery class.
		/// </summary>
		public NgoaiTeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NgoaiTeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NgoaiTeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NgoaiTeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NgoaiTeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NgoaiTeQuery
		
	#region TinTucChuDeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TinTucChuDe"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucChuDeFilters : TinTucChuDeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucChuDeFilters class.
		/// </summary>
		public TinTucChuDeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucChuDeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucChuDeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucChuDeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucChuDeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucChuDeFilters
	
	#region TinTucChuDeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TinTucChuDeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TinTucChuDe"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucChuDeQuery : TinTucChuDeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucChuDeQuery class.
		/// </summary>
		public TinTucChuDeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucChuDeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucChuDeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucChuDeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucChuDeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucChuDeQuery
		
	#region TinTucSuKienFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="TinTucSuKien"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucSuKienFilters : TinTucSuKienFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucSuKienFilters class.
		/// </summary>
		public TinTucSuKienFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucSuKienFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucSuKienFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucSuKienFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucSuKienFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucSuKienFilters
	
	#region TinTucSuKienQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="TinTucSuKienParameterBuilder"/> class
	/// that is used exclusively with a <see cref="TinTucSuKien"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class TinTucSuKienQuery : TinTucSuKienParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the TinTucSuKienQuery class.
		/// </summary>
		public TinTucSuKienQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the TinTucSuKienQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public TinTucSuKienQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the TinTucSuKienQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public TinTucSuKienQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion TinTucSuKienQuery
		
	#region NhaCungCapNganhNgheKinhDoanhFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NhaCungCapNganhNgheKinhDoanh"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaCungCapNganhNgheKinhDoanhFilters : NhaCungCapNganhNgheKinhDoanhFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaCungCapNganhNgheKinhDoanhFilters class.
		/// </summary>
		public NhaCungCapNganhNgheKinhDoanhFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapNganhNgheKinhDoanhFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaCungCapNganhNgheKinhDoanhFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapNganhNgheKinhDoanhFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaCungCapNganhNgheKinhDoanhFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaCungCapNganhNgheKinhDoanhFilters
	
	#region NhaCungCapNganhNgheKinhDoanhQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NhaCungCapNganhNgheKinhDoanhParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NhaCungCapNganhNgheKinhDoanh"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaCungCapNganhNgheKinhDoanhQuery : NhaCungCapNganhNgheKinhDoanhParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaCungCapNganhNgheKinhDoanhQuery class.
		/// </summary>
		public NhaCungCapNganhNgheKinhDoanhQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapNganhNgheKinhDoanhQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaCungCapNganhNgheKinhDoanhQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapNganhNgheKinhDoanhQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaCungCapNganhNgheKinhDoanhQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaCungCapNganhNgheKinhDoanhQuery
		
	#region NganhNgheKinhDoanhFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NganhNgheKinhDoanh"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NganhNgheKinhDoanhFilters : NganhNgheKinhDoanhFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NganhNgheKinhDoanhFilters class.
		/// </summary>
		public NganhNgheKinhDoanhFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NganhNgheKinhDoanhFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NganhNgheKinhDoanhFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NganhNgheKinhDoanhFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NganhNgheKinhDoanhFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NganhNgheKinhDoanhFilters
	
	#region NganhNgheKinhDoanhQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NganhNgheKinhDoanhParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NganhNgheKinhDoanh"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NganhNgheKinhDoanhQuery : NganhNgheKinhDoanhParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NganhNgheKinhDoanhQuery class.
		/// </summary>
		public NganhNgheKinhDoanhQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NganhNgheKinhDoanhQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NganhNgheKinhDoanhQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NganhNgheKinhDoanhQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NganhNgheKinhDoanhQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NganhNgheKinhDoanhQuery
		
	#region NgheNghiepFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NgheNghiep"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NgheNghiepFilters : NgheNghiepFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NgheNghiepFilters class.
		/// </summary>
		public NgheNghiepFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NgheNghiepFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NgheNghiepFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NgheNghiepFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NgheNghiepFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NgheNghiepFilters
	
	#region NgheNghiepQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NgheNghiepParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NgheNghiep"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NgheNghiepQuery : NgheNghiepParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NgheNghiepQuery class.
		/// </summary>
		public NgheNghiepQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NgheNghiepQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NgheNghiepQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NgheNghiepQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NgheNghiepQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NgheNghiepQuery
		
	#region NguoiDungFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NguoiDung"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NguoiDungFilters : NguoiDungFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NguoiDungFilters class.
		/// </summary>
		public NguoiDungFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NguoiDungFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NguoiDungFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NguoiDungFilters
	
	#region NguoiDungQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NguoiDungParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NguoiDung"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NguoiDungQuery : NguoiDungParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NguoiDungQuery class.
		/// </summary>
		public NguoiDungQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NguoiDungQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NguoiDungQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NguoiDungQuery
		
	#region LienHeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="LienHe"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class LienHeFilters : LienHeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the LienHeFilters class.
		/// </summary>
		public LienHeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the LienHeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public LienHeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the LienHeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public LienHeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion LienHeFilters
	
	#region LienHeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="LienHeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="LienHe"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class LienHeQuery : LienHeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the LienHeQuery class.
		/// </summary>
		public LienHeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the LienHeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public LienHeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the LienHeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public LienHeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion LienHeQuery
		
	#region BangGiaSanPhamFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="BangGiaSanPham"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BangGiaSanPhamFilters : BangGiaSanPhamFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BangGiaSanPhamFilters class.
		/// </summary>
		public BangGiaSanPhamFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the BangGiaSanPhamFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BangGiaSanPhamFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BangGiaSanPhamFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BangGiaSanPhamFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BangGiaSanPhamFilters
	
	#region BangGiaSanPhamQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="BangGiaSanPhamParameterBuilder"/> class
	/// that is used exclusively with a <see cref="BangGiaSanPham"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class BangGiaSanPhamQuery : BangGiaSanPhamParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the BangGiaSanPhamQuery class.
		/// </summary>
		public BangGiaSanPhamQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the BangGiaSanPhamQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public BangGiaSanPhamQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the BangGiaSanPhamQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public BangGiaSanPhamQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion BangGiaSanPhamQuery
		
	#region CauHinhHeThongFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="CauHinhHeThong"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CauHinhHeThongFilters : CauHinhHeThongFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CauHinhHeThongFilters class.
		/// </summary>
		public CauHinhHeThongFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the CauHinhHeThongFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CauHinhHeThongFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CauHinhHeThongFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CauHinhHeThongFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CauHinhHeThongFilters
	
	#region CauHinhHeThongQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="CauHinhHeThongParameterBuilder"/> class
	/// that is used exclusively with a <see cref="CauHinhHeThong"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class CauHinhHeThongQuery : CauHinhHeThongParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the CauHinhHeThongQuery class.
		/// </summary>
		public CauHinhHeThongQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the CauHinhHeThongQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public CauHinhHeThongQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the CauHinhHeThongQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public CauHinhHeThongQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion CauHinhHeThongQuery
		
	#region DonViTinhFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="DonViTinh"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DonViTinhFilters : DonViTinhFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DonViTinhFilters class.
		/// </summary>
		public DonViTinhFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the DonViTinhFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DonViTinhFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DonViTinhFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DonViTinhFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DonViTinhFilters
	
	#region DonViTinhQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="DonViTinhParameterBuilder"/> class
	/// that is used exclusively with a <see cref="DonViTinh"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class DonViTinhQuery : DonViTinhParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the DonViTinhQuery class.
		/// </summary>
		public DonViTinhQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the DonViTinhQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public DonViTinhQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the DonViTinhQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public DonViTinhQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion DonViTinhQuery
		
	#region NhaCungCapCauHinhFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NhaCungCapCauHinh"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaCungCapCauHinhFilters : NhaCungCapCauHinhFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaCungCapCauHinhFilters class.
		/// </summary>
		public NhaCungCapCauHinhFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapCauHinhFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaCungCapCauHinhFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapCauHinhFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaCungCapCauHinhFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaCungCapCauHinhFilters
	
	#region NhaCungCapCauHinhQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NhaCungCapCauHinhParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NhaCungCapCauHinh"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaCungCapCauHinhQuery : NhaCungCapCauHinhParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaCungCapCauHinhQuery class.
		/// </summary>
		public NhaCungCapCauHinhQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapCauHinhQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaCungCapCauHinhQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapCauHinhQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaCungCapCauHinhQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaCungCapCauHinhQuery
		
	#region NhaCungCapDiaBanFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NhaCungCapDiaBan"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaCungCapDiaBanFilters : NhaCungCapDiaBanFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaCungCapDiaBanFilters class.
		/// </summary>
		public NhaCungCapDiaBanFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapDiaBanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaCungCapDiaBanFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapDiaBanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaCungCapDiaBanFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaCungCapDiaBanFilters
	
	#region NhaCungCapDiaBanQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NhaCungCapDiaBanParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NhaCungCapDiaBan"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaCungCapDiaBanQuery : NhaCungCapDiaBanParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaCungCapDiaBanQuery class.
		/// </summary>
		public NhaCungCapDiaBanQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapDiaBanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaCungCapDiaBanQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapDiaBanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaCungCapDiaBanQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaCungCapDiaBanQuery
		
	#region NhaCungCapLienHeFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NhaCungCapLienHe"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaCungCapLienHeFilters : NhaCungCapLienHeFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaCungCapLienHeFilters class.
		/// </summary>
		public NhaCungCapLienHeFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapLienHeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaCungCapLienHeFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapLienHeFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaCungCapLienHeFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaCungCapLienHeFilters
	
	#region NhaCungCapLienHeQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NhaCungCapLienHeParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NhaCungCapLienHe"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NhaCungCapLienHeQuery : NhaCungCapLienHeParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NhaCungCapLienHeQuery class.
		/// </summary>
		public NhaCungCapLienHeQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapLienHeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NhaCungCapLienHeQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NhaCungCapLienHeQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NhaCungCapLienHeQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NhaCungCapLienHeQuery
		
	#region NguoiDungVaiTroFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NguoiDungVaiTro"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NguoiDungVaiTroFilters : NguoiDungVaiTroFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NguoiDungVaiTroFilters class.
		/// </summary>
		public NguoiDungVaiTroFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungVaiTroFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NguoiDungVaiTroFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungVaiTroFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NguoiDungVaiTroFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NguoiDungVaiTroFilters
	
	#region NguoiDungVaiTroQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NguoiDungVaiTroParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NguoiDungVaiTro"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NguoiDungVaiTroQuery : NguoiDungVaiTroParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NguoiDungVaiTroQuery class.
		/// </summary>
		public NguoiDungVaiTroQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungVaiTroQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NguoiDungVaiTroQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungVaiTroQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NguoiDungVaiTroQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NguoiDungVaiTroQuery
		
	#region NguoiDungDiaBanFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NguoiDungDiaBan"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NguoiDungDiaBanFilters : NguoiDungDiaBanFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NguoiDungDiaBanFilters class.
		/// </summary>
		public NguoiDungDiaBanFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungDiaBanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NguoiDungDiaBanFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungDiaBanFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NguoiDungDiaBanFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NguoiDungDiaBanFilters
	
	#region NguoiDungDiaBanQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NguoiDungDiaBanParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NguoiDungDiaBan"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NguoiDungDiaBanQuery : NguoiDungDiaBanParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NguoiDungDiaBanQuery class.
		/// </summary>
		public NguoiDungDiaBanQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungDiaBanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NguoiDungDiaBanQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungDiaBanQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NguoiDungDiaBanQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NguoiDungDiaBanQuery
		
	#region NguoiDungNgheNghiepFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NguoiDungNgheNghiep"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NguoiDungNgheNghiepFilters : NguoiDungNgheNghiepFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NguoiDungNgheNghiepFilters class.
		/// </summary>
		public NguoiDungNgheNghiepFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungNgheNghiepFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NguoiDungNgheNghiepFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungNgheNghiepFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NguoiDungNgheNghiepFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NguoiDungNgheNghiepFilters
	
	#region NguoiDungNgheNghiepQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NguoiDungNgheNghiepParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NguoiDungNgheNghiep"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NguoiDungNgheNghiepQuery : NguoiDungNgheNghiepParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NguoiDungNgheNghiepQuery class.
		/// </summary>
		public NguoiDungNgheNghiepQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungNgheNghiepQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NguoiDungNgheNghiepQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungNgheNghiepQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NguoiDungNgheNghiepQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NguoiDungNgheNghiepQuery
		
	#region NguoiDungNhaCungCapFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="NguoiDungNhaCungCap"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NguoiDungNhaCungCapFilters : NguoiDungNhaCungCapFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NguoiDungNhaCungCapFilters class.
		/// </summary>
		public NguoiDungNhaCungCapFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungNhaCungCapFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NguoiDungNhaCungCapFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungNhaCungCapFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NguoiDungNhaCungCapFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NguoiDungNhaCungCapFilters
	
	#region NguoiDungNhaCungCapQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="NguoiDungNhaCungCapParameterBuilder"/> class
	/// that is used exclusively with a <see cref="NguoiDungNhaCungCap"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class NguoiDungNhaCungCapQuery : NguoiDungNhaCungCapParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the NguoiDungNhaCungCapQuery class.
		/// </summary>
		public NguoiDungNhaCungCapQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungNhaCungCapQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public NguoiDungNhaCungCapQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the NguoiDungNhaCungCapQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public NguoiDungNhaCungCapQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion NguoiDungNhaCungCapQuery
		
	#region ViewBangGiaSanPhamFilters
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="SqlFilterBuilder&lt;EntityColumn&gt;"/> class
	/// that is used exclusively with a <see cref="ViewBangGiaSanPham"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ViewBangGiaSanPhamFilters : ViewBangGiaSanPhamFilterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ViewBangGiaSanPhamFilters class.
		/// </summary>
		public ViewBangGiaSanPhamFilters() : base() { }

		/// <summary>
		/// Initializes a new instance of the ViewBangGiaSanPhamFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ViewBangGiaSanPhamFilters(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ViewBangGiaSanPhamFilters class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ViewBangGiaSanPhamFilters(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ViewBangGiaSanPhamFilters
	
	#region ViewBangGiaSanPhamQuery
	
	/// <summary>
	/// A strongly-typed instance of the <see cref="ViewBangGiaSanPhamParameterBuilder"/> class
	/// that is used exclusively with a <see cref="ViewBangGiaSanPham"/> object.
	/// </summary>
	[CLSCompliant(true)]
	public class ViewBangGiaSanPhamQuery : ViewBangGiaSanPhamParameterBuilder
	{
		#region Constructors

		/// <summary>
		/// Initializes a new instance of the ViewBangGiaSanPhamQuery class.
		/// </summary>
		public ViewBangGiaSanPhamQuery() : base() { }

		/// <summary>
		/// Initializes a new instance of the ViewBangGiaSanPhamQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		public ViewBangGiaSanPhamQuery(bool ignoreCase) : base(ignoreCase) { }

		/// <summary>
		/// Initializes a new instance of the ViewBangGiaSanPhamQuery class.
		/// </summary>
		/// <param name="ignoreCase">Specifies whether to create case-insensitive statements.</param>
		/// <param name="useAnd">Specifies whether to combine statements using AND or OR.</param>
		public ViewBangGiaSanPhamQuery(bool ignoreCase, bool useAnd) : base(ignoreCase, useAnd) { }

		#endregion Constructors
	}

	#endregion ViewBangGiaSanPhamQuery
	#endregion

	
}
